home *** CD-ROM | disk | FTP | other *** search
/ University of Pittsburgh…tware Toolkit - Fall 2002 / Toolkit.iso / mac / Macintosh 9.x / Connectivity / Kerberos for Mac 4.0 / Mac OS 9 SDK 4.0 / Kerberos / ClassicGlue / SocketsLib.glue.c < prev    next >
Encoding:
C/C++ Source or Header  |  2002-02-20  |  35.8 KB  |  1,031 lines  |  [TEXT/CWIE]
  1. /* $Copyright:
  2.  *
  3.  * Copyright 1998-2000 by the Massachusetts Institute of Technology.
  4.  * 
  5.  * All rights reserved.
  6.  * 
  7.  * Export of this software from the United States of America may require a
  8.  * specific license from the United States Government.  It is the
  9.  * responsibility of any person or organization contemplating export to
  10.  * obtain such a license before exporting.
  11.  * 
  12.  * WITHIN THAT CONSTRAINT, permission to use, copy, modify, and distribute
  13.  * this software and its documentation for any purpose and without fee is
  14.  * hereby granted, provided that the above copyright notice appear in all
  15.  * copies and that both that copyright notice and this permission notice
  16.  * appear in supporting documentation, and that the name of M.I.T. not be
  17.  * used in advertising or publicity pertaining to distribution of the
  18.  * software without specific, written prior permission.  Furthermore if you
  19.  * modify this software you must label your software as modified software
  20.  * and not distribute it in such a fashion that it might be confused with
  21.  * the original MIT software. M.I.T. makes no representations about the
  22.  * suitability of this software for any purpose.  It is provided "as is"
  23.  * without express or implied warranty.
  24.  * 
  25.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  26.  * WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  27.  * MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  28.  * 
  29.  * Individual source code files are copyright MIT, Cygnus Support,
  30.  * OpenVision, Oracle, Sun Soft, FundsXpress, and others.
  31.  * 
  32.  * Project Athena, Athena, Athena MUSE, Discuss, Hesiod, Kerberos, Moira,
  33.  * and Zephyr are trademarks of the Massachusetts Institute of Technology
  34.  * (MIT).  No commercial use of these trademarks may be made without prior
  35.  * written permission of MIT.
  36.  * 
  37.  * "Commercial use" means use of a name in a product or other for-profit
  38.  * manner.  It does NOT prevent a commercial firm from referring to the MIT
  39.  * trademarks in order to convey information (although in doing so,
  40.  * recognition of their trademark status should be given).
  41.  * $
  42.  */
  43.  
  44. /* $Header: /cvs/macdev/mit/lib/SocketsLib/ClassicGlue/SocketsLib.glue.c,v 1.3 2001/03/21 01:49:00 meeroh Exp $ */
  45.  
  46. #include <CodeFragments.h>
  47. #include <Gestalt.h>
  48. #include <Errors.h>
  49.  
  50. #include <KerberosSupport/Sockets.h>
  51. #include <KerberosSupport/netdb.h>
  52. #include <SocketsLib.glue.h>
  53.  
  54. /* These functions must obey CFM calling conventions. Functions which return
  55.    pointers must return them in D0, not A0 like ThinkC static 68k does.  This way
  56.    we can call CFM functions by pointer from here (if they are called by pointer
  57.    then the compiler can't tell ahead of time to do D0->A0 translation because it
  58.    doesn't know what calling convention the functions use). 
  59.    
  60.    Note that if it is necessary (if you don't use MPWC calling conventions) 
  61.    the D0->A0 translation will be done by the compiler in the places where 
  62.    the application calls these glue routines. */
  63. #pragma d0_pointers on
  64.  
  65. /* Hardcode library fragment name here */
  66. #define kLibraryName "\pMIT Support•SocketsLib"
  67.  
  68. /* Private function prototypes */
  69.  
  70. static OSErr Find_Symbol(
  71.     Ptr* pSymAddr,
  72.     Str255 pSymName,
  73.     ProcInfoType pProcInfo);
  74.  
  75. static pascal Boolean HaveCFM(void);
  76.  
  77. static pascal OSErr GetSystemArchitecture(OSType *archType);
  78.  
  79.  
  80. /* This code is directly from Technote 1077 */
  81. /* changed Library name to be hardcoded at the top of the file
  82.    instead in the middle of the code */
  83.  
  84. /* Private functions */
  85.  
  86. static pascal OSErr GetSystemArchitecture(OSType *archType)
  87. {
  88.     static long sSysArchitecture = 0; // static so we only Gestalt once.
  89.     OSErr tOSErr = noErr;
  90.  
  91.     *archType = kAnyCFragArch;   // assume wild architecture
  92.  
  93.     // If we don't know the system architecture yet...
  94.     if (sSysArchitecture == 0)
  95.     // ...Ask Gestalt what kind of machine we are running on.
  96.     tOSErr = Gestalt(gestaltSysArchitecture, &sSysArchitecture);
  97.  
  98.     if (tOSErr == noErr) // if no errors
  99.     {
  100.         if (sSysArchitecture == gestalt68k)   // 68k?
  101.             *archType = kMotorola68KCFragArch;   
  102.         else if (sSysArchitecture == gestaltPowerPC) // PPC?
  103.             *archType = kPowerPCCFragArch;       
  104.         else
  105.             tOSErr = gestaltUnknownErr;  // who knows what might be next?
  106.     }
  107.     return tOSErr;
  108. }
  109.  
  110. static pascal Boolean HaveCFM(void)
  111. {
  112.     long response;
  113.     return ( (Gestalt (gestaltCFMAttr, &response) == noErr) &&
  114.                 (((response >> gestaltCFMPresent) & 1) != 0));
  115. }
  116.  
  117. static OSErr Find_Symbol(
  118.     Ptr* pSymAddr,
  119.     Str255 pSymName,
  120.     ProcInfoType pProcInfo)
  121. {
  122.     static CFragConnectionID sCID = 0;
  123.     static OSType sArchType = kAnyCFragArch;
  124.     static OSErr sOSErr = noErr;
  125.  
  126.     Str255 errMessage;
  127.     Ptr mainAddr;
  128.     CFragSymbolClass symClass;
  129.     ISAType tISAType;
  130.  
  131.     if (sArchType == kAnyCFragArch)  // if architecture is undefined...
  132.     {
  133.         sCID = 0;     // ...force (re)connect to library
  134.         sOSErr = GetSystemArchitecture(&sArchType); // determine architecture
  135.         if (sOSErr != noErr)
  136.         return sOSErr; // OOPS!
  137.     }
  138.     
  139.     if (!HaveCFM()) {
  140.         // If we don't have CFM68K, return a reasonable-looking error.
  141.         sOSErr = cfragLibConnErr;
  142.         return sOSErr;
  143.     }
  144.  
  145.     if (sArchType == kMotorola68KCFragArch) // ...for CFM68K
  146.         tISAType = kM68kISA | kCFM68kRTA;
  147.     else if (sArchType == kPowerPCCFragArch)  // ...for PPC CFM
  148.         tISAType = kPowerPCISA | kPowerPCRTA;
  149.     else
  150.         sOSErr = gestaltUnknownErr; // who knows what might be next?
  151.  
  152.     if (sCID == 0) // If we haven't connected to the library yet...
  153.     {
  154.         // NOTE: The library name is hard coded here.
  155.         // I try to isolate the glue code, one file per library.
  156.         // I have had developers pass in the Library name to allow
  157.         // plug-in type support. Additional code has to be added to
  158.         // each entry points glue routine to support multiple or
  159.         // switching connection IDs.
  160.         sOSErr = GetSharedLibrary(kLibraryName, sArchType, kLoadCFrag,
  161.         &sCID, &mainAddr, errMessage);
  162.         if (sOSErr != noErr)
  163.         return sOSErr; // OOPS!
  164.     }
  165.  
  166.     // If we haven't looked up this symbol yet...
  167.     if ((Ptr) *pSymAddr == (Ptr) kUnresolvedCFragSymbolAddress)    
  168.     {
  169.         // ...look it up now
  170.         sOSErr = FindSymbol(sCID,pSymName,pSymAddr,&symClass);
  171.         if (sOSErr != noErr) // in case of error...
  172.         // ...clear the procedure pointer
  173.         *(Ptr*) &pSymAddr = (Ptr) kUnresolvedCFragSymbolAddress;
  174. #    if !GENERATINGCFM // if this is classic 68k code...
  175.             *pSymAddr = (Ptr)NewRoutineDescriptorTrap((ProcPtr) *pSymAddr,
  176.             pProcInfo, tISAType);  // ...create a routine descriptor...
  177. #    endif
  178.     }
  179.     return sOSErr;
  180. }
  181.  
  182.  
  183. /* CFM Glue Code for exported functions! */
  184.  
  185. /**** AbortSocketOperation ****/
  186. /* OSStatus AbortSocketOperation(int sockFD); */
  187.  
  188. enum {
  189.   AbortSocketOperation_ProcInfo = kThinkCStackBased 
  190.   | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  191.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  192. };
  193.  
  194.  
  195. typedef OSStatus (*AbortSocketOperation_ProcPtrType)(int);
  196. OSStatus AbortSocketOperation (int sockFD)
  197. {
  198.   static AbortSocketOperation_ProcPtrType AbortSocketOperation_ProcPtr = kUnresolvedCFragSymbolAddress;
  199.     
  200.   // if this symbol has not been setup yet...
  201.   if((Ptr) AbortSocketOperation_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  202.     Find_Symbol((Ptr *) &AbortSocketOperation_ProcPtr, "\pAbortSocketOperation", AbortSocketOperation_ProcInfo);
  203.   if((Ptr) AbortSocketOperation_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  204.     return  AbortSocketOperation_ProcPtr(sockFD);
  205. }
  206.  
  207.  
  208. /**** AbortAllDNSOperations ****/
  209. /* OSStatus AbortAllDNSOperations(void); */
  210.  
  211. enum {
  212.   AbortAllDNSOperations_ProcInfo = kThinkCStackBased 
  213.   | RESULT_SIZE(SIZE_CODE(sizeof(OSStatus)))
  214.  
  215. };
  216.  
  217.  
  218. typedef OSStatus (*AbortAllDNSOperations_ProcPtrType)(void);
  219. OSStatus AbortAllDNSOperations (void)
  220. {
  221.   static AbortAllDNSOperations_ProcPtrType AbortAllDNSOperations_ProcPtr = kUnresolvedCFragSymbolAddress;
  222.     
  223.   // if this symbol has not been setup yet...
  224.   if((Ptr) AbortAllDNSOperations_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  225.     Find_Symbol((Ptr *) &AbortAllDNSOperations_ProcPtr, "\pAbortAllDNSOperations", AbortAllDNSOperations_ProcInfo);
  226.   if((Ptr) AbortAllDNSOperations_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  227.     return  AbortAllDNSOperations_ProcPtr();
  228. }
  229.  
  230.  
  231. /**** IsValidSocket ****/
  232. /* Boolean IsValidSocket(int sockFD); */
  233.  
  234. enum {
  235.   IsValidSocket_ProcInfo = kThinkCStackBased 
  236.   | RESULT_SIZE(SIZE_CODE(sizeof(Boolean)))
  237.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  238. };
  239.  
  240.  
  241. typedef Boolean (*IsValidSocket_ProcPtrType)(int);
  242. Boolean IsValidSocket (int sockFD)
  243. {
  244.   static IsValidSocket_ProcPtrType IsValidSocket_ProcPtr = kUnresolvedCFragSymbolAddress;
  245.     
  246.   // if this symbol has not been setup yet...
  247.   if((Ptr) IsValidSocket_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  248.     Find_Symbol((Ptr *) &IsValidSocket_ProcPtr, "\pIsValidSocket", IsValidSocket_ProcInfo);
  249.   if((Ptr) IsValidSocket_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  250.     return  IsValidSocket_ProcPtr(sockFD);
  251. }
  252.  
  253.  
  254. /**** socket ****/
  255. /* int socket(int family, int type, int protocol); */
  256.  
  257. enum {
  258.   socket_ProcInfo = kThinkCStackBased 
  259.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  260.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  261.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(int)))
  262.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int)))
  263. };
  264.  
  265.  
  266. typedef int (*socket_ProcPtrType)(int, int, int);
  267. int socket (int family,
  268.             int type,
  269.             int protocol)
  270. {
  271.   static socket_ProcPtrType socket_ProcPtr = kUnresolvedCFragSymbolAddress;
  272.     
  273.   // if this symbol has not been setup yet...
  274.   if((Ptr) socket_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  275.     Find_Symbol((Ptr *) &socket_ProcPtr, "\psocket", socket_ProcInfo);
  276.   if((Ptr) socket_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  277.     return  socket_ProcPtr(family, type, protocol);
  278. }
  279.  
  280.  
  281. /**** socket_bind ****/
  282. /* int socket_bind(int sockFD, const struct sockaddr *myAddr, int addrLength); */
  283.  
  284. enum {
  285.   socket_bind_ProcInfo = kThinkCStackBased 
  286.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  287.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  288.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const struct sockaddr *)))
  289.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int)))
  290. };
  291.  
  292.  
  293. typedef int (*socket_bind_ProcPtrType)(int, const struct sockaddr *, int);
  294. int socket_bind (int sockFD,
  295.                  const struct sockaddr * myAddr,
  296.                  int addrLength)
  297. {
  298.   static socket_bind_ProcPtrType socket_bind_ProcPtr = kUnresolvedCFragSymbolAddress;
  299.     
  300.   // if this symbol has not been setup yet...
  301.   if((Ptr) socket_bind_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  302.     Find_Symbol((Ptr *) &socket_bind_ProcPtr, "\psocket_bind", socket_bind_ProcInfo);
  303.   if((Ptr) socket_bind_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  304.     return  socket_bind_ProcPtr(sockFD, myAddr, addrLength);
  305. }
  306.  
  307.  
  308. /**** socket_fcntl ****/
  309. /* int socket_fcntl(int sockFD, int command, int flags); */
  310.  
  311. enum {
  312.   socket_fcntl_ProcInfo = kThinkCStackBased 
  313.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  314.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  315.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(int)))
  316.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int)))
  317. };
  318.  
  319.  
  320. typedef int (*socket_fcntl_ProcPtrType)(int, int, int);
  321. int socket_fcntl (int sockFD,
  322.                   int command,
  323.                   int flags)
  324. {
  325.   static socket_fcntl_ProcPtrType socket_fcntl_ProcPtr = kUnresolvedCFragSymbolAddress;
  326.     
  327.   // if this symbol has not been setup yet...
  328.   if((Ptr) socket_fcntl_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  329.     Find_Symbol((Ptr *) &socket_fcntl_ProcPtr, "\psocket_fcntl", socket_fcntl_ProcInfo);
  330.   if((Ptr) socket_fcntl_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  331.     return  socket_fcntl_ProcPtr(sockFD, command, flags);
  332. }
  333.  
  334.  
  335. /**** socket_close ****/
  336. /* int socket_close(int sockFD); */
  337.  
  338. enum {
  339.   socket_close_ProcInfo = kThinkCStackBased 
  340.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  341.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  342. };
  343.  
  344.  
  345. typedef int (*socket_close_ProcPtrType)(int);
  346. int socket_close (int sockFD)
  347. {
  348.   static socket_close_ProcPtrType socket_close_ProcPtr = kUnresolvedCFragSymbolAddress;
  349.     
  350.   // if this symbol has not been setup yet...
  351.   if((Ptr) socket_close_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  352.     Find_Symbol((Ptr *) &socket_close_ProcPtr, "\psocket_close", socket_close_ProcInfo);
  353.   if((Ptr) socket_close_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  354.     return  socket_close_ProcPtr(sockFD);
  355. }
  356.  
  357.  
  358. /**** socket_shutdown ****/
  359. /* int socket_shutdown(int sockFD, int howTo); */
  360.  
  361. enum {
  362.   socket_shutdown_ProcInfo = kThinkCStackBased 
  363.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  364.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  365.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(int)))
  366. };
  367.  
  368.  
  369. typedef int (*socket_shutdown_ProcPtrType)(int, int);
  370. int socket_shutdown (int sockFD,
  371.                      int howTo)
  372. {
  373.   static socket_shutdown_ProcPtrType socket_shutdown_ProcPtr = kUnresolvedCFragSymbolAddress;
  374.     
  375.   // if this symbol has not been setup yet...
  376.   if((Ptr) socket_shutdown_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  377.     Find_Symbol((Ptr *) &socket_shutdown_ProcPtr, "\psocket_shutdown", socket_shutdown_ProcInfo);
  378.   if((Ptr) socket_shutdown_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  379.     return  socket_shutdown_ProcPtr(sockFD, howTo);
  380. }
  381.  
  382.  
  383. /**** socket_connect ****/
  384. /* int socket_connect(int sockFD, struct sockaddr *servAddr, int addrLength); */
  385.  
  386. enum {
  387.   socket_connect_ProcInfo = kThinkCStackBased 
  388.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  389.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  390.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(struct sockaddr *)))
  391.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int)))
  392. };
  393.  
  394.  
  395. typedef int (*socket_connect_ProcPtrType)(int, struct sockaddr *, int);
  396. int socket_connect (int sockFD,
  397.                     struct sockaddr * servAddr,
  398.                     int addrLength)
  399. {
  400.   static socket_connect_ProcPtrType socket_connect_ProcPtr = kUnresolvedCFragSymbolAddress;
  401.     
  402.   // if this symbol has not been setup yet...
  403.   if((Ptr) socket_connect_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  404.     Find_Symbol((Ptr *) &socket_connect_ProcPtr, "\psocket_connect", socket_connect_ProcInfo);
  405.   if((Ptr) socket_connect_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  406.     return  socket_connect_ProcPtr(sockFD, servAddr, addrLength);
  407. }
  408.  
  409.  
  410. /**** socket_select ****/
  411. /* int socket_select(int maxFDsExamined, fd_set *readFDs, fd_set *writeFDs, fd_set *exceptFDs, struct timeval *timeOut); */
  412.  
  413. enum {
  414.   socket_select_ProcInfo = kThinkCStackBased 
  415.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  416.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  417.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(fd_set *)))
  418.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(fd_set *)))
  419.   | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(fd_set *)))
  420.   | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(struct timeval *)))
  421. };
  422.  
  423.  
  424. typedef int (*socket_select_ProcPtrType)(int, fd_set *, fd_set *, fd_set *, struct timeval *);
  425. int socket_select (int maxFDsExamined,
  426.                    fd_set * readFDs,
  427.                    fd_set * writeFDs,
  428.                    fd_set * exceptFDs,
  429.                    struct timeval * timeOut)
  430. {
  431.   static socket_select_ProcPtrType socket_select_ProcPtr = kUnresolvedCFragSymbolAddress;
  432.     
  433.   // if this symbol has not been setup yet...
  434.   if((Ptr) socket_select_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  435.     Find_Symbol((Ptr *) &socket_select_ProcPtr, "\psocket_select", socket_select_ProcInfo);
  436.   if((Ptr) socket_select_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  437.     return  socket_select_ProcPtr(maxFDsExamined, readFDs, writeFDs, exceptFDs, timeOut);
  438. }
  439.  
  440.  
  441. /**** socket_getpeername ****/
  442. /* int socket_getpeername(int sockFD, struct sockaddr *peerAddr, int *addrLength); */
  443.  
  444. enum {
  445.   socket_getpeername_ProcInfo = kThinkCStackBased 
  446.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  447.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  448.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(struct sockaddr *)))
  449.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int *)))
  450. };
  451.  
  452.  
  453. typedef int (*socket_getpeername_ProcPtrType)(int, struct sockaddr *, int *);
  454. int socket_getpeername (int sockFD,
  455.                         struct sockaddr * peerAddr,
  456.                         int * addrLength)
  457. {
  458.   static socket_getpeername_ProcPtrType socket_getpeername_ProcPtr = kUnresolvedCFragSymbolAddress;
  459.     
  460.   // if this symbol has not been setup yet...
  461.   if((Ptr) socket_getpeername_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  462.     Find_Symbol((Ptr *) &socket_getpeername_ProcPtr, "\psocket_getpeername", socket_getpeername_ProcInfo);
  463.   if((Ptr) socket_getpeername_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  464.     return  socket_getpeername_ProcPtr(sockFD, peerAddr, addrLength);
  465. }
  466.  
  467.  
  468. /**** socket_getsockname ****/
  469. /* int socket_getsockname(int sockFD, struct sockaddr *localAddr, int *addrLength); */
  470.  
  471. enum {
  472.   socket_getsockname_ProcInfo = kThinkCStackBased 
  473.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  474.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  475.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(struct sockaddr *)))
  476.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int *)))
  477. };
  478.  
  479.  
  480. typedef int (*socket_getsockname_ProcPtrType)(int, struct sockaddr *, int *);
  481. int socket_getsockname (int sockFD,
  482.                         struct sockaddr * localAddr,
  483.                         int * addrLength)
  484. {
  485.   static socket_getsockname_ProcPtrType socket_getsockname_ProcPtr = kUnresolvedCFragSymbolAddress;
  486.     
  487.   // if this symbol has not been setup yet...
  488.   if((Ptr) socket_getsockname_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  489.     Find_Symbol((Ptr *) &socket_getsockname_ProcPtr, "\psocket_getsockname", socket_getsockname_ProcInfo);
  490.   if((Ptr) socket_getsockname_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  491.     return  socket_getsockname_ProcPtr(sockFD, localAddr, addrLength);
  492. }
  493.  
  494.  
  495. /**** socket_read ****/
  496. /* int socket_read(int sockFD, void *buffer, UInt32 numBytes); */
  497.  
  498. enum {
  499.   socket_read_ProcInfo = kThinkCStackBased 
  500.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  501.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  502.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  503.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  504. };
  505.  
  506.  
  507. typedef int (*socket_read_ProcPtrType)(int, void *, UInt32);
  508. int socket_read (int sockFD,
  509.                  void * buffer,
  510.                  UInt32 numBytes)
  511. {
  512.   static socket_read_ProcPtrType socket_read_ProcPtr = kUnresolvedCFragSymbolAddress;
  513.     
  514.   // if this symbol has not been setup yet...
  515.   if((Ptr) socket_read_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  516.     Find_Symbol((Ptr *) &socket_read_ProcPtr, "\psocket_read", socket_read_ProcInfo);
  517.   if((Ptr) socket_read_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  518.     return  socket_read_ProcPtr(sockFD, buffer, numBytes);
  519. }
  520.  
  521.  
  522. /**** socket_write ****/
  523. /* int socket_write(int sockFD, void *buffer, UInt32 numBytes); */
  524.  
  525. enum {
  526.   socket_write_ProcInfo = kThinkCStackBased 
  527.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  528.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  529.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  530.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  531. };
  532.  
  533.  
  534. typedef int (*socket_write_ProcPtrType)(int, void *, UInt32);
  535. int socket_write (int sockFD,
  536.                   void * buffer,
  537.                   UInt32 numBytes)
  538. {
  539.   static socket_write_ProcPtrType socket_write_ProcPtr = kUnresolvedCFragSymbolAddress;
  540.     
  541.   // if this symbol has not been setup yet...
  542.   if((Ptr) socket_write_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  543.     Find_Symbol((Ptr *) &socket_write_ProcPtr, "\psocket_write", socket_write_ProcInfo);
  544.   if((Ptr) socket_write_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  545.     return  socket_write_ProcPtr(sockFD, buffer, numBytes);
  546. }
  547.  
  548.  
  549. /**** socket_readv ****/
  550. /* int socket_readv(int sockFD, struct iovec *iov, UInt32 iovCount); */
  551.  
  552. enum {
  553.   socket_readv_ProcInfo = kThinkCStackBased 
  554.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  555.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  556.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(struct iovec *)))
  557.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  558. };
  559.  
  560.  
  561. typedef int (*socket_readv_ProcPtrType)(int, struct iovec *, UInt32);
  562. int socket_readv (int sockFD,
  563.                   struct iovec * iov,
  564.                   UInt32 iovCount)
  565. {
  566.   static socket_readv_ProcPtrType socket_readv_ProcPtr = kUnresolvedCFragSymbolAddress;
  567.     
  568.   // if this symbol has not been setup yet...
  569.   if((Ptr) socket_readv_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  570.     Find_Symbol((Ptr *) &socket_readv_ProcPtr, "\psocket_readv", socket_readv_ProcInfo);
  571.   if((Ptr) socket_readv_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  572.     return  socket_readv_ProcPtr(sockFD, iov, iovCount);
  573. }
  574.  
  575.  
  576. /**** socket_writev ****/
  577. /* int socket_writev(int sockFD, struct iovec *iov, UInt32 iovCount); */
  578.  
  579. enum {
  580.   socket_writev_ProcInfo = kThinkCStackBased 
  581.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  582.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  583.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(struct iovec *)))
  584.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  585. };
  586.  
  587.  
  588. typedef int (*socket_writev_ProcPtrType)(int, struct iovec *, UInt32);
  589. int socket_writev (int sockFD,
  590.                    struct iovec * iov,
  591.                    UInt32 iovCount)
  592. {
  593.   static socket_writev_ProcPtrType socket_writev_ProcPtr = kUnresolvedCFragSymbolAddress;
  594.     
  595.   // if this symbol has not been setup yet...
  596.   if((Ptr) socket_writev_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  597.     Find_Symbol((Ptr *) &socket_writev_ProcPtr, "\psocket_writev", socket_writev_ProcInfo);
  598.   if((Ptr) socket_writev_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  599.     return  socket_writev_ProcPtr(sockFD, iov, iovCount);
  600. }
  601.  
  602.  
  603. /**** socket_recv ****/
  604. /* int socket_recv(int sockFD, void *buffer, UInt32 numBytes, int flags); */
  605.  
  606. enum {
  607.   socket_recv_ProcInfo = kThinkCStackBased 
  608.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  609.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  610.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  611.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  612.   | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int)))
  613. };
  614.  
  615.  
  616. typedef int (*socket_recv_ProcPtrType)(int, void *, UInt32, int);
  617. int socket_recv (int sockFD,
  618.                  void * buffer,
  619.                  UInt32 numBytes,
  620.                  int flags)
  621. {
  622.   static socket_recv_ProcPtrType socket_recv_ProcPtr = kUnresolvedCFragSymbolAddress;
  623.     
  624.   // if this symbol has not been setup yet...
  625.   if((Ptr) socket_recv_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  626.     Find_Symbol((Ptr *) &socket_recv_ProcPtr, "\psocket_recv", socket_recv_ProcInfo);
  627.   if((Ptr) socket_recv_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  628.     return  socket_recv_ProcPtr(sockFD, buffer, numBytes, flags);
  629. }
  630.  
  631.  
  632. /**** socket_send ****/
  633. /* int socket_send(int sockFD, void *buffer, UInt32 numBytes, int flags); */
  634.  
  635. enum {
  636.   socket_send_ProcInfo = kThinkCStackBased 
  637.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  638.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  639.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  640.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  641.   | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int)))
  642. };
  643.  
  644.  
  645. typedef int (*socket_send_ProcPtrType)(int, void *, UInt32, int);
  646. int socket_send (int sockFD,
  647.                  void * buffer,
  648.                  UInt32 numBytes,
  649.                  int flags)
  650. {
  651.   static socket_send_ProcPtrType socket_send_ProcPtr = kUnresolvedCFragSymbolAddress;
  652.     
  653.   // if this symbol has not been setup yet...
  654.   if((Ptr) socket_send_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  655.     Find_Symbol((Ptr *) &socket_send_ProcPtr, "\psocket_send", socket_send_ProcInfo);
  656.   if((Ptr) socket_send_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  657.     return  socket_send_ProcPtr(sockFD, buffer, numBytes, flags);
  658. }
  659.  
  660.  
  661. /**** socket_recvfrom ****/
  662. /* int socket_recvfrom(int sockFD, void *buffer, UInt32 numBytes, int flags, struct sockaddr *fromAddr, socklen_t *addrLength); */
  663.  
  664. enum {
  665.   socket_recvfrom_ProcInfo = kThinkCStackBased 
  666.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  667.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  668.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  669.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  670.   | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int)))
  671.   | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(struct sockaddr *)))
  672.   | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(socklen_t *)))
  673. };
  674.  
  675.  
  676. typedef int (*socket_recvfrom_ProcPtrType)(int, void *, UInt32, int, struct sockaddr *, socklen_t *);
  677. int socket_recvfrom (int sockFD,
  678.                      void * buffer,
  679.                      UInt32 numBytes,
  680.                      int flags,
  681.                      struct sockaddr * fromAddr,
  682.                      socklen_t * addrLength)
  683. {
  684.   static socket_recvfrom_ProcPtrType socket_recvfrom_ProcPtr = kUnresolvedCFragSymbolAddress;
  685.     
  686.   // if this symbol has not been setup yet...
  687.   if((Ptr) socket_recvfrom_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  688.     Find_Symbol((Ptr *) &socket_recvfrom_ProcPtr, "\psocket_recvfrom", socket_recvfrom_ProcInfo);
  689.   if((Ptr) socket_recvfrom_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  690.     return  socket_recvfrom_ProcPtr(sockFD, buffer, numBytes, flags, fromAddr, addrLength);
  691. }
  692.  
  693.  
  694. /**** socket_sendto ****/
  695. /* int socket_sendto(int sockFD, void *buffer, UInt32 numBytes, int flags, struct sockaddr *toAddr, socklen_t addrLength); */
  696.  
  697. enum {
  698.   socket_sendto_ProcInfo = kThinkCStackBased 
  699.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  700.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  701.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(void *)))
  702.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(UInt32)))
  703.   | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(int)))
  704.   | STACK_ROUTINE_PARAMETER(5, SIZE_CODE(sizeof(struct sockaddr *)))
  705.   | STACK_ROUTINE_PARAMETER(6, SIZE_CODE(sizeof(socklen_t)))
  706. };
  707.  
  708.  
  709. typedef int (*socket_sendto_ProcPtrType)(int, void *, UInt32, int, struct sockaddr *, socklen_t);
  710. int socket_sendto (int sockFD,
  711.                    void * buffer,
  712.                    UInt32 numBytes,
  713.                    int flags,
  714.                    struct sockaddr * toAddr,
  715.                    socklen_t addrLength)
  716. {
  717.   static socket_sendto_ProcPtrType socket_sendto_ProcPtr = kUnresolvedCFragSymbolAddress;
  718.     
  719.   // if this symbol has not been setup yet...
  720.   if((Ptr) socket_sendto_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  721.     Find_Symbol((Ptr *) &socket_sendto_ProcPtr, "\psocket_sendto", socket_sendto_ProcInfo);
  722.   if((Ptr) socket_sendto_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  723.     return  socket_sendto_ProcPtr(sockFD, buffer, numBytes, flags, toAddr, addrLength);
  724. }
  725.  
  726.  
  727. /**** inet_ntoa ****/
  728. /* char* inet_ntoa(struct in_addr addr); */
  729.  
  730. enum {
  731.   inet_ntoa_ProcInfo = kThinkCStackBased 
  732.   | RESULT_SIZE(SIZE_CODE(sizeof(char*)))
  733.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(struct in_addr)))
  734. };
  735.  
  736.  
  737. typedef char* (*inet_ntoa_ProcPtrType)(struct in_addr);
  738. char* inet_ntoa (struct in_addr addr)
  739. {
  740.   static inet_ntoa_ProcPtrType inet_ntoa_ProcPtr = kUnresolvedCFragSymbolAddress;
  741.     
  742.   // if this symbol has not been setup yet...
  743.   if((Ptr) inet_ntoa_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  744.     Find_Symbol((Ptr *) &inet_ntoa_ProcPtr, "\pinet_ntoa", inet_ntoa_ProcInfo);
  745.   if((Ptr) inet_ntoa_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  746.     return  inet_ntoa_ProcPtr(addr);
  747. }
  748.  
  749.  
  750. /**** inet_aton ****/
  751. /* int inet_aton(const char *str, struct in_addr *addr); */
  752.  
  753. enum {
  754.   inet_aton_ProcInfo = kThinkCStackBased 
  755.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  756.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const char *)))
  757.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(struct in_addr *)))
  758. };
  759.  
  760.  
  761. typedef int (*inet_aton_ProcPtrType)(const char *, struct in_addr *);
  762. int inet_aton (const char * str,
  763.                struct in_addr * addr)
  764. {
  765.   static inet_aton_ProcPtrType inet_aton_ProcPtr = kUnresolvedCFragSymbolAddress;
  766.     
  767.   // if this symbol has not been setup yet...
  768.   if((Ptr) inet_aton_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  769.     Find_Symbol((Ptr *) &inet_aton_ProcPtr, "\pinet_aton", inet_aton_ProcInfo);
  770.   if((Ptr) inet_aton_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  771.     return  inet_aton_ProcPtr(str, addr);
  772. }
  773.  
  774.  
  775. /**** inet_addr ****/
  776. /* in_addr_t inet_addr(const char *str); */
  777.  
  778. enum {
  779.   inet_addr_ProcInfo = kThinkCStackBased 
  780.   | RESULT_SIZE(SIZE_CODE(sizeof(in_addr_t)))
  781.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const char *)))
  782. };
  783.  
  784.  
  785. typedef in_addr_t (*inet_addr_ProcPtrType)(const char *);
  786. in_addr_t inet_addr (const char * str)
  787. {
  788.   static inet_addr_ProcPtrType inet_addr_ProcPtr = kUnresolvedCFragSymbolAddress;
  789.     
  790.   // if this symbol has not been setup yet...
  791.   if((Ptr) inet_addr_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  792.     Find_Symbol((Ptr *) &inet_addr_ProcPtr, "\pinet_addr", inet_addr_ProcInfo);
  793.   if((Ptr) inet_addr_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  794.     return  inet_addr_ProcPtr(str);
  795. }
  796.  
  797.  
  798. /**** inet_pton ****/
  799. /* int inet_pton(int family, const char *str, void *addr); */
  800.  
  801. enum {
  802.   inet_pton_ProcInfo = kThinkCStackBased 
  803.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  804.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  805.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char *)))
  806.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(void *)))
  807. };
  808.  
  809.  
  810. typedef int (*inet_pton_ProcPtrType)(int, const char *, void *);
  811. int inet_pton (int family,
  812.                const char * str,
  813.                void * addr)
  814. {
  815.   static inet_pton_ProcPtrType inet_pton_ProcPtr = kUnresolvedCFragSymbolAddress;
  816.     
  817.   // if this symbol has not been setup yet...
  818.   if((Ptr) inet_pton_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  819.     Find_Symbol((Ptr *) &inet_pton_ProcPtr, "\pinet_pton", inet_pton_ProcInfo);
  820.   if((Ptr) inet_pton_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  821.     return  inet_pton_ProcPtr(family, str, addr);
  822. }
  823.  
  824.  
  825. /**** inet_ntop ****/
  826. /* const char* inet_ntop(int family, const void *addr, char *str, size_t len); */
  827.  
  828. enum {
  829.   inet_ntop_ProcInfo = kThinkCStackBased 
  830.   | RESULT_SIZE(SIZE_CODE(sizeof(const char*)))
  831.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  832.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const void *)))
  833.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(char *)))
  834.   | STACK_ROUTINE_PARAMETER(4, SIZE_CODE(sizeof(size_t)))
  835. };
  836.  
  837.  
  838. typedef const char* (*inet_ntop_ProcPtrType)(int, const void *, char *, size_t);
  839. const char* inet_ntop (int family,
  840.                        const void * addr,
  841.                        char * str,
  842.                        size_t len)
  843. {
  844.   static inet_ntop_ProcPtrType inet_ntop_ProcPtr = kUnresolvedCFragSymbolAddress;
  845.     
  846.   // if this symbol has not been setup yet...
  847.   if((Ptr) inet_ntop_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  848.     Find_Symbol((Ptr *) &inet_ntop_ProcPtr, "\pinet_ntop", inet_ntop_ProcInfo);
  849.   if((Ptr) inet_ntop_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  850.     return  inet_ntop_ProcPtr(family, addr, str, len);
  851. }
  852.  
  853.  
  854. /**** gethostbyname ****/
  855. /* struct hostent* gethostbyname(const char *hostname); */
  856.  
  857. enum {
  858.   gethostbyname_ProcInfo = kThinkCStackBased 
  859.   | RESULT_SIZE(SIZE_CODE(sizeof(struct hostent*)))
  860.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const char *)))
  861. };
  862.  
  863.  
  864. typedef struct hostent* (*gethostbyname_ProcPtrType)(const char *);
  865. struct hostent* gethostbyname (const char * hostname)
  866. {
  867.   static gethostbyname_ProcPtrType gethostbyname_ProcPtr = kUnresolvedCFragSymbolAddress;
  868.     
  869.   // if this symbol has not been setup yet...
  870.   if((Ptr) gethostbyname_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  871.     Find_Symbol((Ptr *) &gethostbyname_ProcPtr, "\pgethostbyname", gethostbyname_ProcInfo);
  872.   if((Ptr) gethostbyname_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  873.     return  gethostbyname_ProcPtr(hostname);
  874. }
  875.  
  876.  
  877. /**** gethostbyaddr ****/
  878. /* struct hostent* gethostbyaddr(const char *addr, size_t len, int family); */
  879.  
  880. enum {
  881.   gethostbyaddr_ProcInfo = kThinkCStackBased 
  882.   | RESULT_SIZE(SIZE_CODE(sizeof(struct hostent*)))
  883.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const char *)))
  884.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(size_t)))
  885.   | STACK_ROUTINE_PARAMETER(3, SIZE_CODE(sizeof(int)))
  886. };
  887.  
  888.  
  889. typedef struct hostent* (*gethostbyaddr_ProcPtrType)(const char *, size_t, int);
  890. struct hostent* gethostbyaddr (const char * addr,
  891.                                size_t len,
  892.                                int family)
  893. {
  894.   static gethostbyaddr_ProcPtrType gethostbyaddr_ProcPtr = kUnresolvedCFragSymbolAddress;
  895.     
  896.   // if this symbol has not been setup yet...
  897.   if((Ptr) gethostbyaddr_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  898.     Find_Symbol((Ptr *) &gethostbyaddr_ProcPtr, "\pgethostbyaddr", gethostbyaddr_ProcInfo);
  899.   if((Ptr) gethostbyaddr_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  900.     return  gethostbyaddr_ProcPtr(addr, len, family);
  901. }
  902.  
  903.  
  904. /**** gethostname ****/
  905. /* int gethostname(char *name, size_t namelen); */
  906.  
  907. enum {
  908.   gethostname_ProcInfo = kThinkCStackBased 
  909.   | RESULT_SIZE(SIZE_CODE(sizeof(int)))
  910.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(char *)))
  911.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(size_t)))
  912. };
  913.  
  914.  
  915. typedef int (*gethostname_ProcPtrType)(char *, size_t);
  916. int gethostname (char * name,
  917.                  size_t namelen)
  918. {
  919.   static gethostname_ProcPtrType gethostname_ProcPtr = kUnresolvedCFragSymbolAddress;
  920.     
  921.   // if this symbol has not been setup yet...
  922.   if((Ptr) gethostname_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  923.     Find_Symbol((Ptr *) &gethostname_ProcPtr, "\pgethostname", gethostname_ProcInfo);
  924.   if((Ptr) gethostname_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  925.     return  gethostname_ProcPtr(name, namelen);
  926. }
  927.  
  928.  
  929. /**** getservent ****/
  930. /* struct servent* getservent (void); */
  931.  
  932. enum {
  933.   getservent_ProcInfo = kThinkCStackBased 
  934.   | RESULT_SIZE(SIZE_CODE(sizeof(struct servent*)))
  935.  
  936. };
  937.  
  938.  
  939. typedef struct servent* (*getservent_ProcPtrType)(void);
  940. struct servent* getservent (void)
  941. {
  942.   static getservent_ProcPtrType getservent_ProcPtr = kUnresolvedCFragSymbolAddress;
  943.     
  944.   // if this symbol has not been setup yet...
  945.   if((Ptr) getservent_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  946.     Find_Symbol((Ptr *) &getservent_ProcPtr, "\pgetservent", getservent_ProcInfo);
  947.   if((Ptr) getservent_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  948.     return  getservent_ProcPtr();
  949. }
  950.  
  951.  
  952. /**** endservent ****/
  953. /* void endservent (void); */
  954.  
  955. enum {
  956.   endservent_ProcInfo = kThinkCStackBased 
  957.  
  958. };
  959.  
  960.  
  961. typedef void (*endservent_ProcPtrType)(void);
  962. void endservent (void)
  963. {
  964.   static endservent_ProcPtrType endservent_ProcPtr = kUnresolvedCFragSymbolAddress;
  965.     
  966.   // if this symbol has not been setup yet...
  967.   if((Ptr) endservent_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  968.     Find_Symbol((Ptr *) &endservent_ProcPtr, "\pendservent", endservent_ProcInfo);
  969.   if((Ptr) endservent_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  970.       endservent_ProcPtr();
  971. }
  972.  
  973.  
  974. /**** getservbyname ****/
  975. /* struct servent* getservbyname (const char *servname, const char *protname); */
  976.  
  977. enum {
  978.   getservbyname_ProcInfo = kThinkCStackBased 
  979.   | RESULT_SIZE(SIZE_CODE(sizeof(struct servent*)))
  980.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(const char *)))
  981.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char *)))
  982. };
  983.  
  984.  
  985. typedef struct servent* (*getservbyname_ProcPtrType)(const char *, const char *);
  986. struct servent* getservbyname (const char * servname,
  987.                                const char * protname)
  988. {
  989.   static getservbyname_ProcPtrType getservbyname_ProcPtr = kUnresolvedCFragSymbolAddress;
  990.     
  991.   // if this symbol has not been setup yet...
  992.   if((Ptr) getservbyname_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  993.     Find_Symbol((Ptr *) &getservbyname_ProcPtr, "\pgetservbyname", getservbyname_ProcInfo);
  994.   if((Ptr) getservbyname_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  995.     return  getservbyname_ProcPtr(servname, protname);
  996. }
  997.  
  998.  
  999. /**** getservbyport ****/
  1000. /* struct servent* getservbyport (int port, const char *protname); */
  1001.  
  1002. enum {
  1003.   getservbyport_ProcInfo = kThinkCStackBased 
  1004.   | RESULT_SIZE(SIZE_CODE(sizeof(struct servent*)))
  1005.   | STACK_ROUTINE_PARAMETER(1, SIZE_CODE(sizeof(int)))
  1006.   | STACK_ROUTINE_PARAMETER(2, SIZE_CODE(sizeof(const char *)))
  1007. };
  1008.  
  1009.  
  1010. typedef struct servent* (*getservbyport_ProcPtrType)(int, const char *);
  1011. struct servent* getservbyport (int port,
  1012.                                const char * protname)
  1013. {
  1014.   static getservbyport_ProcPtrType getservbyport_ProcPtr = kUnresolvedCFragSymbolAddress;
  1015.     
  1016.   // if this symbol has not been setup yet...
  1017.   if((Ptr) getservbyport_ProcPtr == (Ptr) kUnresolvedCFragSymbolAddress)
  1018.     Find_Symbol((Ptr *) &getservbyport_ProcPtr, "\pgetservbyport", getservbyport_ProcInfo);
  1019.   if((Ptr) getservbyport_ProcPtr != (Ptr) kUnresolvedCFragSymbolAddress)
  1020.     return  getservbyport_ProcPtr(port, protname);
  1021. }
  1022.  
  1023.  
  1024. Boolean SocketsLibraryIsPresent(void)
  1025. {
  1026.     Ptr    symAddr;
  1027.     return (Find_Symbol (&symAddr, "\psocket", socket_ProcInfo)) == noErr;
  1028. }
  1029.  
  1030.  
  1031.